home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / escalant / escala21.lha / escalante2.1 / src / editor / EscalanteView.h < prev    next >
C/C++ Source or Header  |  1993-07-15  |  16KB  |  863 lines
  1. //
  2. //    Copyright (C) 1993  Jeff McWhirter
  3. //
  4. #ifndef EscalanteView_First
  5. #define EscalanteView_First
  6.  
  7. #include    "EscalanteGlobal.h"
  8.  
  9. #include    "View.h"
  10. #include    "ObjList.h"
  11. #include    "Stack.h"
  12. #include    "Dialog.h"
  13. #include    "Set.h"
  14. #include     "Buttons.h"
  15.  
  16. #include    "VGraphElement.h"
  17. #include    "VRelation.h"
  18. #include    "VEntity.h" 
  19. #include     "ObjectGrid.h"
  20.  
  21. #ifdef USE_STRUCTURAL
  22. #include    "SGraphElement.h"
  23. #include    "SRelation.h"
  24. #include    "SEntity.h" 
  25. #endif
  26.  
  27. #include    "Geometry.h"
  28.  
  29.  
  30.  
  31. class    TextField;
  32. class    VObject;
  33.  
  34.  
  35. enum ErrorReturn {
  36.     eAbort,
  37.     eContinue,
  38.     eAbortButSaveElements};
  39.  
  40.  
  41. #define ADDSV(sclass,vclass,vg)\
  42. ve = new vclass();se = new sclass();\
  43. ve->IfFalseDontWriteOutOriginal(FALSE); \
  44. se->IfFalseDontWriteOutOriginal(FALSE);\
  45. se->AddVGelt(ve);ve->SetSGelt(se);\
  46. se->Init();ve->Init();\
  47. if(vg->GetSGelt())\
  48.     vg->GetSGelt()->AddPrototype(se);\
  49. vg->AddPrototype(ve);
  50.  
  51.  
  52.  
  53.  
  54.  
  55. #define ADDV(vclass,vg)\
  56. ve = new vclass();\
  57. ve->IfFalseDontWriteOutOriginal(FALSE);\
  58. ve->Init();\
  59. vg->AddPrototype(ve);
  60.  
  61.  
  62.  
  63. #define ADDSVTOLIST(sclass,vclass,list)\
  64. ve = new vclass();se = new sclass();\
  65. ve->IfFalseDontWriteOutOriginal(FALSE);\
  66. se->IfFalseDontWriteOutOriginal(FALSE);\
  67. se->AddVGelt(ve); ve->SetSGelt(se);\
  68. se->Init();ve->Init();\
  69. list.Add(ve);
  70.  
  71.  
  72.  
  73.  
  74. #define ADDVTOLIST(vclass,list)\
  75. ve = new vclass();\
  76. ve->IfFalseDontWriteOutOriginal(FALSE);\
  77. ve->Init();\
  78. list.Add(ve);
  79.  
  80.  
  81.  
  82. #define NEWELT(sclass, sname,vclass,vname){\
  83. sname = new sclass ();\
  84. vname = new vclass();\
  85. sname->AddVGelt(vname);\
  86. vname->SetSGelt(sname);\
  87. sname->Init(); vname->Init();\
  88. }
  89.  
  90.  
  91.  
  92.  
  93. #define NEWENT(vclass,vname,sname){\
  94. sname = new SEntity ();\
  95. vname = new vclass();\
  96. sname->AddVGelt(vname);\
  97. vname->SetSGelt(sname);\
  98. sname->Init(); vname->Init();\
  99. }
  100.  
  101. #define NEWREL(vclass,vname,sname){\
  102. sname= new SRelation ();\
  103. vname = new vclass();\
  104. sname->Init(); vname->Init();\
  105. sname->AddVGelt(vname);\
  106. vname->SetSGelt(sname);\
  107. }
  108.  
  109.  
  110. #define    PALETTE_LEFT 0
  111. #define PALETTE_TOP 1
  112. #define PALETTE_RIGHT 2
  113. #define PALETTE_BOTTOM 3
  114.  
  115.  
  116.  
  117. extern bool    gDoKeyCommands;
  118. extern ObjList    gExtraPaletteItems;
  119. extern bool    gGraphModified;
  120. extern bool    gAlwaysAddMultiples;
  121. extern int    gGravity;
  122. extern bool    gRubberBand;
  123. extern bool    gNameInPalette;
  124. extern bool    gBitmapInPalette;
  125. extern Point    gPaletteItemSize;
  126. extern Point    gPaletteGap;
  127. extern Point    gViewSize;
  128. extern Point    gGridSize;
  129. extern bool    gDoBell;
  130. extern bool    gTransNewGraph;
  131. extern bool    gTransNorth;
  132. extern int    gPaletteRows;
  133. extern int    gPaletteCols;
  134. extern int    gPaletteThreshold;
  135. extern int     gPaletteOrientation;
  136. extern bool    gMakePalette;
  137. extern class Stack * gViewStack;
  138. extern bool     gNoRepeatAdd;
  139. extern bool    gPickInEdit;
  140. extern bool    gDeleteInEdit;
  141.  
  142. class Ink;
  143. extern Ink * gViewInk;
  144.  
  145. const int    cIdPalette=    1100;
  146. const int    cGridSize=    10;
  147. const int    cChangedGraph=    3000;
  148. const int    cPaletteChanged=33333; 
  149. const int    cViewClosed=    33334; 
  150.  
  151.  
  152. enum Needs     {
  153.     NEED_NONE = 0,
  154.     NEED_ENTITY,
  155.     NEED_RELATION,
  156.     NEED_TAIL,
  157.     NEED_HEAD,
  158.     NEED_ELEMENT,
  159.     NEED_E1E2,
  160.     NEED_POINT,
  161.     NEED_JOINT,
  162.     NEED_GFX
  163. };
  164.    
  165.  
  166.  
  167.  
  168. //
  169. //Menu Ids
  170. //
  171. enum MenuIds{
  172.     cALLDV     = cUSERCMD,
  173.     cDVMENU,
  174.     cOPTIONSMENU,
  175.     cJOINTSMENU,
  176.     cGFXMENU,
  177.     cPICKMENU,
  178.     cESCALANTE_EDITMENU,
  179.     cMOVEMENU,
  180.     cSCALEMENU,
  181.     cRELMENU,
  182.     cEVENTDEPMENU,
  183.     cTLTOHDMENU,
  184.     cHDTOTLMENU,
  185.     cTLTORELMENU,
  186.     cHDTORELMENU,
  187.     cRELTOHDMENU,
  188.     cRELTOTLMENU,
  189.     cDELMENU,
  190.     cALIGNMENU,
  191.     cGROUPMENU,
  192.     cESCALANTEVIEWMENU,
  193.     cZOOMMENU,
  194.     cFLAGMENU,
  195.     cDELGROUPMENU,
  196.     cESCALANTELASTMENUID
  197.     };
  198.     
  199.  
  200.  
  201.  
  202.  
  203. enum Actions {
  204. FIRST_ESCALANTE_CMD = cUSERCMD+1000,
  205.  
  206. FLUSH_COMMANDS,
  207.  
  208. ADD_ENTITY,
  209. ADD_RELATION,
  210.  
  211. DELETE_ELEMENT,
  212. DELETE_ENTITY,
  213. DELETE_RELATION,
  214. DELETE_GROUP,
  215. DELETE_ALL,
  216.  
  217.  
  218.  
  219. PICK_SINGLE_ELEMENT,
  220. PICK_SINGLE_ENTITY,
  221. PICK_SINGLE_RELATION,
  222. PICK_SINGLE_WITH_TYPE, 
  223.  
  224. PICK_GROUP_ELEMENT,
  225. PICK_GROUP_ENTITY,
  226. PICK_GROUP_RELATION,
  227. PICK_GROUP_WITH_TYPE,
  228.  
  229. ADD_SINGLE_ELEMENT,
  230. ADD_SINGLE_ENTITY,
  231. ADD_SINGLE_RELATION,
  232.  
  233. ADD_GROUP_ELEMENT,
  234. ADD_GROUP_ENTITY,
  235. ADD_GROUP_RELATION,
  236.  
  237. REMOVE_SINGLE_ELEMENT,
  238.  
  239. CLEARERROR,
  240.  
  241. SETPROTOTYPE,
  242. ADDPROTOTYPE,
  243.  
  244. ACCEPTINPUT,
  245. CHECKTLHD,
  246. RUBBERBAND,
  247. CLEARRECT,
  248. CLEARPICKED,
  249.  
  250. REMOVETAIL,
  251. REMOVEHEAD,
  252.  
  253. MOVETAIL,
  254. MOVEHEAD,
  255.  
  256. SETTAIL,
  257. SETHEAD,
  258.  
  259. GFXTOFRONT,
  260. GFXTOBACK,
  261. STRETCH_GFX,
  262. MOVE_GFX,
  263. BORDER_GFX,
  264.  
  265. TURNOFF,
  266. TURNOFFGROUP,
  267.  
  268. TOFRONT,
  269. TOBACK,
  270. MOVE,
  271. QUICKMOVE,
  272. MOVEGROUP,
  273. ALIGNB,
  274. ALIGNT,
  275. ALIGNR,
  276. ALIGNL,
  277. ALIGNCX,
  278. ALIGNCY,
  279. ALIGNBAT,
  280. ALIGNTAT,
  281. ALIGNRAT,
  282. ALIGNLAT,
  283. ALIGNCXAT,
  284. ALIGNCYAT,
  285. SPACEX,
  286. SPACEY,
  287. LAYOUTHOR,
  288. LAYOUTVER,
  289. SCALE,
  290. RESHAPERECT,
  291. RESHAPEPT,
  292. ROTATE,
  293. SHRINK,
  294. SHRINK_X,
  295. SHRINK_Y,
  296.  
  297. ADD_JOINT,
  298. REMOVE_JOINT,
  299. MOVE_JOINT,
  300. ADD_JOINTF,
  301. REMOVE_JOINTF,
  302. ADD_JOINTL,
  303. REMOVE_JOINTL,
  304.  
  305.  
  306. DRAWRECT,
  307.  
  308.  
  309.  
  310. PRINT_POINT,
  311. MEASURE,
  312. GRID,
  313. MULTIPLES,
  314. INCGRID,
  315. DECGRID,
  316. SHWGRID,
  317. REDRAW,
  318.  
  319. ALLVS,
  320. LCHINT,
  321. MOVEHINT,
  322. SCALEHINT,
  323. DIEHINT,
  324. COPYHINT,
  325.  
  326.  
  327. SHOVE,
  328. SUCK,
  329.  
  330. PUSH,
  331. POP,
  332. ADDVIEW,
  333. REMOVEVIEW,
  334. NEWVIEWNEWELT,
  335. NEWVIEWOLDELT,
  336. COPYVGRAPH,
  337. COPYNEWVGRAPH,
  338. EXITVIEW,
  339. INSERTVIEW,
  340.  
  341. WRITE_TEXT_TO_FILE,
  342. READ_TEXT_FROM_FILE,
  343.  
  344.  
  345.  
  346.  
  347.  
  348. ABOUTVIEW,
  349. ABOUTMISC,
  350. ABOUTELT,
  351. ABOUTCURRENTMODE,
  352. ABOUTMODE,
  353.  
  354.  
  355.  
  356.  
  357.  
  358. eEventDepBase,
  359. eTlToHdBase     =  eEventDepBase,
  360. eTlToRelBase    =  eEventDepBase +50, 
  361. eHdToTlBase     = eEventDepBase +100, 
  362. eHdToRelBase     = eEventDepBase +150, 
  363. eRelToTlBase     = eEventDepBase +200, 
  364. eRelToHdBase     = eEventDepBase +250, 
  365. eEventDepLast     =  eEventDepBase+300,
  366.  
  367.  
  368.  
  369. ACTION_NONE,
  370. ESCALANTEVIEWLASTACTION = ACTION_NONE +1000
  371. };
  372.  
  373. enum PaletteActions{
  374.     SETTOOL = ESCALANTEVIEWLASTACTION+1
  375. };
  376.  
  377.  
  378.  
  379. #define BaseEscalanteView_BASE View
  380.  
  381. enum BaseEscalanteViewFlags{eBaseEscalanteViewDrawingRect    = BIT(eViewLast+1),
  382.               eEscalanteBaseViewShowGrid     = BIT(eViewLast+2),
  383.               eSendInput        = BIT(eViewLast+3),
  384.               ePickingTl        = BIT(eViewLast+4),
  385.               ePickingHd        = BIT(eViewLast+5),
  386.               eCheckTlHd        = BIT(eViewLast+6),
  387.               eAllVs            = BIT(eViewLast+7),
  388.               eDoGrid             = BIT(eViewLast+8),
  389.                   eAddMultiples   = BIT(eViewLast+9),
  390.               eBaseEscalanteViewLast        = eViewLast+9
  391.               };
  392.  
  393.  
  394.  
  395. enum ViewType{
  396.     eSimpleView,
  397.     eLastViewType};
  398.  
  399. class BaseEscalanteView: public BaseEscalanteView_BASE {
  400. public:
  401. Rectangle    selectionRect;
  402. class Set      selectionSet;
  403. VGraphElement*    vgraph;
  404. Stack        stack;
  405. int        id;
  406. Point        grid;
  407. Actions        action;
  408. Needs        need;
  409. Class*        neededClass;
  410. Class*        neededClass2;
  411. VGraphElement*    e1,*e2;
  412. VGraphElement*    NeededElt;
  413. TextField*    error;
  414. TextField*    info;
  415.  
  416. ElementOkFunc    pickfunc;
  417. ElementOkFunc    drawfunc;
  418. VGraphElement*    currentElt;
  419. ViewType    type;
  420.  
  421.  
  422.  
  423. MetaDef(BaseEscalanteView);
  424. BaseEscalanteView(int id,class Document*, Point, VGraphElement*);
  425.  
  426. ~BaseEscalanteView();
  427. virtual  VObject*    GetView();
  428. virtual void        InitView(){}
  429.  
  430.  
  431. void FlushCommand(); 
  432.  
  433. class ShowText* GetTextDialog(char * mess, char * title);
  434.  
  435.  
  436. virtual    ObjectGrid* GetGrid(){return (vgraph?vgraph->GetGrid():0);}
  437.  
  438.  
  439. virtual char * GetDescription(){return 0;}
  440. virtual char * GetElementDescription(VGraphElement*){return 0;}
  441. virtual char * GetActionDescription(Actions);
  442.  
  443. virtual void SignalError(char * c);
  444. virtual void ClearError();
  445.  
  446. virtual void SignalMode(char * c);
  447. virtual void ClearMode();
  448.  
  449.  
  450.  
  451. bool SendInput(){return TestFlag(eSendInput);}
  452. void SendInput(bool b){SetFlag(eSendInput,b);}
  453.  
  454. bool AllVs(){return TestFlag(eAllVs);}
  455. void AllVs(bool b){SetFlag(eAllVs,b);}
  456.  
  457. bool CheckTlHd(){return TestFlag(eCheckTlHd);}
  458. void CheckTlHd(bool b){SetFlag(eCheckTlHd,b);}
  459.  
  460.  
  461. bool PickingTl(){return TestFlag(ePickingTl);}
  462. void PickingTl(bool b){SetFlag(ePickingTl,b);}
  463.  
  464. bool PickingHd(){return TestFlag(ePickingHd);}
  465. void PickingHd(bool b){SetFlag(ePickingHd,b);}
  466.  
  467. virtual bool ElementOk(VGraphElement * e,bool pick);
  468. virtual bool OkToDraw(VGraphElement * e);
  469. virtual bool OkToPick(VGraphElement * e);
  470.  
  471. virtual ErrorReturn CouldNotFindHead(VRelation*,Set*s=0);
  472. virtual ErrorReturn CouldNotFindTail(VRelation*,Set*s=0);
  473.  
  474. virtual void    DoneAddingElement(VGraphElement*){}
  475. virtual void    DoneAddingElements(class Set*){}
  476. virtual void    DoneMovingElement(VGraphElement*){}
  477. virtual bool    OkToDeleteElement(VGraphElement*){return TRUE;}
  478. virtual ElementOkFunc GetHeadFunc(VRelation*){return 0;}
  479. virtual ElementOkFunc GetTailFunc(VRelation*){return 0;}
  480.  
  481.  
  482.  
  483.  
  484.  
  485.  
  486.  
  487.  
  488.  
  489. void SetDrawFunc(ElementOkFunc f){drawfunc = f; ForceRedraw();}
  490. void SetPickFunc(ElementOkFunc f){pickfunc = f;}
  491.  
  492.  
  493. virtual void VGraphDied(VGraphElement * vg);
  494. virtual char * ActionName(Actions action);
  495.  
  496.  
  497.  
  498.  
  499.  
  500.  
  501. void HideGfx(int gfxid, bool state , ObjList * list = 0);
  502.  
  503. void Draw(Rectangle);
  504. virtual void DrawGraph(Rectangle r);
  505. virtual Command* Interested(int cmd,int part=0, void * data=0);
  506. virtual bool SetAction(Actions m,void * data =0){return SetAction2(m,data);}
  507. virtual bool SetAction2(Actions m,void * data =0);
  508.  
  509.  
  510. virtual void ExitView();
  511. virtual bool PopGraph();
  512. virtual void NewGraph(VGraphElement *, bool push = FALSE);
  513. virtual void GetNewGraph(VGraphElement *  vg,VGraphElement * & newvg){    newvg = vg;}
  514.  
  515. void Zoom(float f);
  516. Rectangle GetVRect();
  517.  
  518.  
  519. //The following 4 methods allow one to  define what kind of object is needed and of what type.
  520.  
  521. virtual void SetNeed(Needs n,class Class * neededClass ,class Class * neededClass2  ,ElementOkFunc f );
  522.  
  523. virtual void SetNeed(Needs n){SetNeed(n,(Class*)0,(Class*)0,0);}
  524.  
  525. virtual void SetNeed(Needs n,class Class * cl){    SetNeed(n,cl,(Class*)0,0);}
  526.  
  527.  
  528. virtual void SetNeed(Needs n,class Class * cl,Class* cl2){SetNeed(n,cl,cl2,0);}
  529.  
  530.  
  531. virtual void SetNeed(Needs n,ElementOkFunc f){SetNeed(n,(Class*)0,(Class*)0,f);}
  532.  
  533.  
  534. void RectDrawn(bool f){
  535.     if(f != RectDrawn()){
  536.         SetFlag(eBaseEscalanteViewDrawingRect,f);
  537.         InvalidateRect(selectionRect);
  538.         if(f)    selectionRect = gRect0;
  539.     }
  540. }
  541. bool RectDrawn(){return TestFlag(eBaseEscalanteViewDrawingRect);}
  542. virtual void DoneDrawingRect(); 
  543. void SetSelectionRect(Rectangle);
  544.  
  545. void    DoObserve(int id, int part, void *d , Object *op);
  546. Command *DoMenuCommand(int cmd);
  547. Command *DoLeftButtonDownCommand(Point p, Token t, int i);
  548. Command *DoMiddleButtonDownCommand(Point p, Token t, int i);
  549.  
  550.  
  551.  
  552.  
  553.  
  554. bool ShowGrid(){return TestFlag(eEscalanteBaseViewShowGrid);}
  555. void ShowGrid(bool b){SetFlag(eEscalanteBaseViewShowGrid,b);}
  556.  
  557. bool DoGrid(){return TestFlag(eDoGrid);}
  558. void DoGrid(bool b){SetFlag(eDoGrid,b);}
  559.  
  560. bool Multiples(){return TestFlag(eAddMultiples);}
  561. void Multiples(bool b){SetFlag(eAddMultiples,b);}
  562. virtual bool AddMultiples(VGraphElement *){return Multiples();}
  563.  
  564. void    ClearPickGroup();
  565.  
  566.  
  567.  
  568. void     SetPickGroup(class Class * c =0);
  569. void     AddToPickGroup(class Class * c =0);
  570. void     SetPickGroup(VGraphElement *);
  571. void     AddToPickGroup(VGraphElement *);
  572. virtual void HighlightElement(VGraphElement * vg,bool on = TRUE);
  573. void  AlignElementsAt(Set * s, Actions action,Point);
  574. void SpaceElements(Set *, Actions );
  575.  
  576.  
  577. };
  578.  
  579.  
  580.  
  581.  
  582.  
  583.  
  584. enum EscalanteViewFlags{eEscalanteViewMakePalette = BIT(eBaseEscalanteViewLast+1),
  585.           eEscalanteViewLast = eBaseEscalanteViewLast+1};
  586.  
  587.                 
  588. #define EscalanteView_BASE  BaseEscalanteView
  589.  
  590. class EscalanteView: public EscalanteView_BASE {
  591.  public:
  592.     bool sendingInput;
  593.  
  594.     VGraphElement * cvproto;
  595.     Gfx * cgfx;
  596.     VObject * focus;
  597.     class CollectionView *paletteView;
  598.     ObjList    *tools;
  599.     ObjList    *allprotos;
  600.     VObject    *paletteWrapper;
  601.  
  602.    
  603. public:
  604.     MetaDef(EscalanteView);
  605.     EscalanteView(int id,class Document*, Point, VGraphElement*,bool makePalette = TRUE);
  606.  
  607.  
  608.     ~EscalanteView();
  609.     void InitView();    
  610.     bool OkToPick(VGraphElement * e);
  611.  
  612.     virtual bool NewHeadOk(VRelation* nr,VGraphElement *e);
  613.     virtual bool NewTailOk(VRelation* nr,VGraphElement *e);
  614.     void NewGraph( VGraphElement *, bool push = FALSE);
  615.     void AddPrototype(VGraphElement * vg);
  616.     void    DoObserve(int id, int part, void *d , Object *op);
  617.  
  618.  
  619.     char * GetActionDescription(Actions);
  620.  
  621.  
  622.     virtual int GetOrientation();
  623.     virtual int GetRows();
  624.     virtual int GetCols();
  625.  
  626.  
  627.     virtual char *  GetTextToWrite(VGraphElement*){return 0;}
  628.     virtual void HereIsSomeText(char *,VGraphElement*){}
  629.  
  630.  
  631.  
  632.  
  633. //
  634. //How big are the palette items
  635. //
  636.     virtual Point GetPaletteItemSize();    
  637.  
  638. //
  639. //Overrides the ETRC MakeSeparatePalette when it (the ETRC flag ) is FALSE
  640. //
  641.     virtual bool MakeSeparatePalette(){return FALSE;}
  642.  
  643. //
  644. //Overrides the ETRC MakeExtraPalette when it (the ETRC flag ) is TRUE
  645. //
  646.     virtual bool DoNotMakeExtraPalette(){return FALSE;}
  647.  
  648.  
  649. //
  650. //Overrides the ETRC MakeObserverView when it (the ETRC flag ) is TRUE
  651. //
  652.     virtual bool DoNotMakeObserverView(){return FALSE;}
  653.  
  654. //
  655. //Overrides the ETRC MakePalette when it (the ETRC flag ) is set to false
  656. //
  657.     virtual bool ForceMakePalette(){return FALSE;}
  658.  
  659.  
  660. //
  661. //You can also set a bit in this view to determine whether to make the palette
  662. //
  663.  
  664.     bool MakePalette(){return TestFlag(eEscalanteViewMakePalette);}
  665.     void MakePalette(bool b){SetFlag(eEscalanteViewMakePalette,b);}
  666.  
  667.  
  668.     virtual ObjList * GetProtoList();
  669.     bool SetAction(Actions m,void * data =0);
  670.     bool SetAction2(Actions m,void * data =0);
  671.  
  672.     char * ActionName(Actions action);
  673.     void ClearPicked();
  674.  
  675.     virtual class VObject * GetView();
  676.     class  CollectionView * GetPalette();
  677.     virtual void MakeToolList();    
  678.     virtual void AddToToolList(ObjList *l){} 
  679.  
  680.     virtual VObject * GetTopVObj();
  681.     virtual VObject * GetMiddleVObj();
  682.     virtual VObject * GetBottomVObj();
  683.  
  684.  
  685.  
  686.  
  687.     Command* SatisfyNeeds(Point tp,VGraphElement * & cvelt ,VEntity * & cve  ,VRelation *& cvr);
  688.     Command* SatisfyNeeds(Point tp,VGraphElement * & cvelt ,VEntity * & cve  ,VRelation *& cvr,Gfx * & gfx );
  689.     void Draw(Rectangle);
  690.      
  691.     void SetTool(VGraphElement*);
  692.     void ClearTool();
  693.  
  694.     Command* Interested(int cmd,int part=0, void * data=0);
  695.     Command *DoMiddleButtonDownCommand(Point p, Token t, int i);
  696.     Command *DoLeftButtonDownCommand(Point, Token, int);
  697.     Command *DoKeyCommand(int, Token);
  698.     
  699.  
  700.     static Menu* MakeMenu(int );
  701.     void     DoSetupMenu(class Menu*);
  702.  
  703.     void Control(int id, int part, void *val);    
  704.     Command *DispatchEvents(Point lp, Token &t, Clipper *vf) ;
  705.     GrCursor GetCursor(Point);
  706.  
  707. };
  708.  
  709.  
  710.  
  711.  
  712.  
  713.  
  714.  
  715.  
  716.  
  717.  
  718.  
  719. #define ObserverView_BASE EscalanteView
  720. class ObserverView: public ObserverView_BASE {
  721. public:
  722. EscalanteView * theView;
  723. MetaDef(ObserverView);
  724. ObserverView(EscalanteView* v,int id,class Document* doc, Point pt, VGraphElement*vg,bool makePalette):ObserverView_BASE(id,doc,pt,vg,makePalette){
  725.     theView = v;    theView->AddObserver(this);
  726. }
  727. void    DoObserve(int id, int part, void *d , Object *op);
  728. VObject * GetTopVObj(){return 0;}
  729. VObject * GetBottomVObj(){return 0;}
  730. };
  731.  
  732.  
  733.  
  734.  
  735.  
  736.  
  737. #define ScaledObserverView_BASE ObserverView
  738. class ScaledObserverView: public ScaledObserverView_BASE {
  739. public:
  740. float zoomFactor;
  741. MetaDef(ScaledObserverView);
  742. ScaledObserverView(EscalanteView* v,
  743.            int id,
  744.            class Document* doc,
  745.            Point pt,
  746.            VGraphElement*vg,
  747.            bool makePalette):
  748. ScaledObserverView_BASE(v,id,doc,pt,vg,makePalette){
  749.     zoomFactor = 0.5;
  750. }
  751. void    DoObserve(int id, int part, void *d , Object *op);
  752. void InitObserver(float f = 0.5);
  753. void Resize();
  754. void Draw(Rectangle);
  755. };
  756.  
  757.  
  758. class PaletteButton:public VObjectButton{
  759. public: 
  760.     MetaDef(PaletteButton)
  761.     PaletteButton(int id,VObject*vop,int st = 0):VObjectButton(id,vop,st){}
  762.     void DrawInner(Rectangle r, bool highlight);
  763.     void SetOrigin(Point);
  764. };
  765.  
  766.  
  767. class PaletteItem: public VObject {
  768. public:
  769. Point size;
  770. VGraphElement * elt;
  771. char * str;
  772. Bitmap *  bm;
  773. MetaDef(PaletteItem);
  774. PaletteItem(VGraphElement * e,Point p = gPoint16);
  775. PaletteItem(char * s,Point p = gPoint16);
  776. PaletteItem(Bitmap * bm,Point p = gPoint16);
  777. void Init(VGraphElement * e,Point p = gPoint16);
  778. void Draw(Rectangle r);
  779. Metric GetMinSize();
  780. };
  781.  
  782.  
  783.  
  784.  
  785.  
  786.  
  787.  
  788.  
  789.  
  790. class ShowText: public Manager{
  791. public:
  792. MetaDef(ShowText);
  793. class CheapText * textobj;
  794. char * text;
  795. ShowText(char * t=0,char * title = 0);
  796. VObject* DoMakeContent();
  797. MenuBar * DoMakeMenuBar(){return 0;}
  798. void Control(int id, int part, void *val);    
  799. };
  800.  
  801.  
  802.  
  803.  
  804. //
  805. //You can use the EscalanteDialog class as a basis to create
  806. //your own dialog box class.  Overwrite the appropriate methods.
  807. //To show a dialog box do a dialog->ShowUnderMouse();
  808. // 
  809.  
  810.  
  811. #include "Dialog.h"
  812. class EscalanteDialog : public Dialog {
  813. public:
  814. VGraphElement * elt;
  815.  
  816. MetaDef(EscalanteDialog);
  817. EscalanteDialog(VGraphElement * e=0,char *title= "Dialog");
  818.  
  819. //
  820. //You can overwrite this method if you don't want the "OK"  and "Cancel" buttons
  821. //
  822. VObject *DoMakeContent();
  823.  
  824. //
  825. //Overwrite this method to give the guts of the dialog
  826. //
  827.     virtual VObject * GetInner(){return 0;}
  828.  
  829. //
  830. //This is what gets called when something happens in the dialog
  831. //e.g. OK button pressed
  832. //
  833.     void Control(int id, int, void *v);
  834.  
  835.  
  836. //
  837. //By default this method gets called from the Control method when the OK or 
  838. //cancel button gets called. The arg is either cIdOk or cIdCancel.
  839. //
  840.  
  841. virtual void Done(int ){}
  842. };
  843.  
  844.  
  845.  
  846.  
  847. class  TextFieldDialog: public EscalanteDialog{
  848. public:
  849. TextField * text;
  850. TextFieldDialog(char * init = 0);
  851. ~TextFieldDialog();
  852. VObject * GetInner ();
  853. char * GetText();
  854. };
  855.  
  856.  
  857.  
  858.  
  859.  
  860.  
  861. #endif 
  862.  
  863.